//给你一个大小为 m x n 的二维矩阵 grid 。你需要判断每一个格子 grid[i][j] 是否满足： 
//
// 
// 如果它下面的格子存在，那么它需要等于它下面的格子，也就是 grid[i][j] == grid[i + 1][j] 。 
// 如果它右边的格子存在，那么它需要不等于它右边的格子，也就是 grid[i][j] != grid[i][j + 1] 。 
// 
//
// 如果 所有 格子都满足以上条件，那么返回 true ，否则返回 false 。 
//
// 
//
// 示例 1： 
//
// 
// 输入：grid = [[1,0,2],[1,0,2]] 
// 
//
// 输出：true 
//
// 解释： 
//
// 
//
// 网格图中所有格子都符合条件。 
//
// 示例 2： 
//
// 
// 输入：grid = [[1,1,1],[0,0,0]] 
// 
//
// 输出：false 
//
// 解释： 
//
// 
//
// 同一行中的格子值都相等。 
//
// 示例 3： 
//
// 
// 输入：grid = [[1],[2],[3]] 
// 
//
// 输出：false 
//
// 解释： 
//
// 
//
// 同一列中的格子值不相等。 
//
// 
//
// 提示： 
//
// 
// 1 <= n, m <= 10 
// 0 <= grid[i][j] <= 9 
// 
//
// Related Topics 数组 矩阵 👍 9 👎 0


package com.tyrone.leetcode.editor.cn;

import com.tyrone.leetcode.util.CodeUtils;

import java.util.concurrent.atomic.AtomicInteger;

public class CheckIfGridSatisfiesConditions {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(0);
        System.out.println(atomicInteger.getAndIncrement());
        Solution solution = new CheckIfGridSatisfiesConditions().new Solution();
        System.out.println(solution.satisfiesConditions(CodeUtils.toDoubleArray("[[1,0,2],[1,0,2]]")));
    }

    //leetcode submit region begin(Prohibit modification and deletion)
    class Solution {
        public boolean satisfiesConditions(int[][] grid) {
//            int[][] dir = new int[][]{{1, 0}, {0, 1}};
//            int n = grid.length;
//            int m = grid[0].length;
//            for (int i = 0; i < n; i++) {
//                for (int j = 0; j < m; j++) {
//                    boolean flag = true;
//
//                    if (i + dir[0][0] < n && j + dir[0][1] < m && grid[i][j] != grid[i + dir[0][0]][j + dir[0][1]]) {
//                        flag = false;
//                    }
//                    if (i + dir[1][0] < n && j + dir[1][1] < m && grid[i][j] == grid[i + dir[1][0]][j + dir[1][1]]) {
//                        flag = false;
//                    }
//
//                    if (!flag) {
//                        return false;
//                    }
//                }
//            }
//            return true;

            /**
             * 复盘：看了一下解体思路，直接遍循环就可以了，不需要再定义一个dir来表示右边和下面的
             *      并且直接从后面往前对比，这样避免了判断越界问题
             */
            int n = grid.length;
            int m = grid[0].length;
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    if (j > 0 && grid[i][j] == grid[i][j - 1] ||
                            i > 0 && grid[i][j] != grid[i - 1][j]) {
                        return false;
                    }
                }
            }
            return true;
        }
    }
//leetcode submit region end(Prohibit modification and deletion)

}